home *** CD-ROM | disk | FTP | other *** search
/ Otherware / Otherware_1_SB_Development.iso / mac / developm / librarie / kemo103.cpt / KeMo 1.03 ƒ / KeMoTest.c < prev   
Encoding:
C/C++ Source or Header  |  1992-09-18  |  7.6 KB  |  269 lines
  1. #include <stdio.h>
  2. #include <ctype.h>
  3. #include <time.h>
  4. #include "KeMo.h"
  5.  
  6. void AccuracyTest(void);
  7. void ResponseTest(void);
  8. void TimerTest(void);
  9. void ScreenTest(void);
  10. void KeyCodesTest(void);
  11. void ShowHideMBar(void); 
  12.  
  13. /* Main menu */
  14. main()
  15. {
  16.     char ans[20];
  17.     long err;
  18.  
  19.     printf("Welcome to KeMo's test suite!\n");
  20.  
  21.     KeMoInit(KeMoQuiet + KeMoAltKeys);    /* no beeps on errors (but do show alerts) */
  22.                                         /* also, set keyboard to differentiate between
  23.                                             left and right modifier keys */
  24.     
  25.     while(1) {
  26.         printf("\nThe following tests are available:\n");
  27.         printf("    [A]ccuracy        - measures keyboard and mouse detection accuracy\n");
  28.         printf("                        (uses KeMoAccuracy)\n");
  29.         printf("    [E]nd Programs    - end all other running programs (uses KeMoQuitAllApps)\n");
  30.         printf("    [K]eys            - reports symbol for keys pressed (uses KeMoCode2Asc)\n");
  31.         printf("    [M]enus           - show/hide menu bar\n");
  32.         printf("    [R]esponses       - checks detection of up and down calls to KeMoWait\n");
  33.         printf("    [S]creen Refresh  - calls KeMoSynch on every screen refresh for 20 seconds\n");
  34.         printf("                        and reports what should be the monitor's refresh rate\n");
  35.         printf("    [T]imer           - checks the accuracy of the timer against the Mac clock\n");
  36.         printf("    [Q]uit\n");
  37.         printf("\nPlease select one of the above: ");
  38.         fflush(stdout);
  39.         
  40.         fgets(ans, 10, stdin);
  41.         
  42.         switch (toupper(*ans)) {
  43.             case 'A': AccuracyTest(); break;
  44.             case 'E': KeMoQuitAllApps(); break;
  45.             case 'K': KeyCodesTest(); break;
  46.             case 'M': ShowHideMBar(); break;
  47.             case 'R': ResponseTest(); break;
  48.             case 'T': TimerTest(); break;
  49.             case 'S': ScreenTest(); break;
  50.             case 'Q': ExitToShell(); break;
  51.             default: printf("Your choice is not recognized.  Please try again.\n");
  52.                     continue;
  53.             }
  54.         }
  55. }
  56.  
  57.  
  58. void ShowHideMBar() 
  59. {
  60.     long err;
  61.     
  62.     if ( (err = KeMoShowMBar()) && (err = KeMoHideMBar()) )
  63.         printf("\n*** Call to menu bar operation returned error code %ld.\n", err);
  64.     return;
  65. }
  66.  
  67. void KeyCodesTest() {
  68.     KeMoParms parms;
  69.     char c;
  70.     long err;
  71.  
  72.     if (err = KeMoSelect(KeMoKey))    {    /* select the keyboard */
  73.         printf("\n*** Couldn't select keyboard only at this time (%ld).\n", err);
  74.         return;
  75.         }
  76.     
  77.     c = 0;
  78.     printf("\nPress one key at a time.  To end, press 'q' or press no keys for 5 seconds.\n");
  79.  
  80.     while (c != 'q' && c != '!') {    /* end with q or timeout (shows up as ! returned
  81.                                         by KeMoCode2Asc) */
  82.                                         
  83.         KeMoWait(KeMoDown, 5000L, &parms);    /* wait for a kepypress up to 5 seconds */
  84.         
  85.         c = KeMoCode2Asc(parms.key);    /* convert the key code to ASCII representation */
  86.         
  87.         if (c < 10)                    /* keypad numbers */
  88.             printf("K%c ", c+'0');
  89.         else if (c < 20)            /* function keys 1-9 */
  90.             printf("F%c ", c-10+'0');
  91.         else if (c < 30)            /* function keys 10-15 */
  92.             printf("F1%c ", c-20+'0');
  93.         else                        /* other key */
  94.             printf("%c ", c);
  95.         fflush(stdout);
  96.         }
  97.     printf("\n\n");
  98.     KeMoReset();        /* undo selection of keyboard only */
  99. }
  100.  
  101. void ScreenTest()
  102. {
  103.     long x;
  104.     long t, i;
  105.  
  106.     if (x = KeMoSync(1)) {
  107.         printf("Can't do screen sync: error %ld\n", x);
  108.         return;
  109.         }
  110.         
  111.     printf("\nThis test takes 20 seconds.  Please be patient.\n");
  112.     
  113.     i = 0;                /* Time is updated once a second by the Mac
  114.                             (it's a low-memory Mac variable) */
  115.     t = Time + 1;
  116.     while (t > Time);    /* wait for a fresh second */
  117.     
  118.     while (t + 20 > Time) {        /* call KeMoSync for exactly 20 seconds */
  119.         KeMoSync(1);
  120.         i++;
  121.         }
  122.         
  123.     printf("This monitor's screen refresh rate is approximately %.1f Hz.\n", i/20.0);
  124.     
  125.     return;
  126. }
  127.  
  128.  
  129. void TimerTest()
  130. {
  131.     long t;
  132.     
  133.     printf("\nThis test runs for 10 seconds.  Press any key in about 7 seconds (at beep).\n");
  134.     printf("If you hear a second beep, you did not press a key in time (press a key anyway\n");
  135.     printf("to stop the test).\n");
  136.     
  137.     t = KeMoTimerTest();        /* this function takes care of this test */
  138.                                 /* it returns microseconds */
  139.     if (t < 0)
  140.         printf("\nThere was an error: %ld.  Perhaps you didn't press the key early enough?\n", t);
  141.     else
  142.         printf("\nTimer accuracy while looking for keyboard: %ld msecs/sec.\n", (long)(t/1000.0 + .5));
  143.     
  144.     printf("\nRunning Delay test (1 second).\n");
  145.     KeMoTimerStart();
  146.     KeMoDelay(1000L);
  147.     t = KeMoTimerStop(KeMoNoCorrection);
  148.     
  149.     printf("A delay of 1000 msecs takes %ld msecs to complete.\n", t);
  150. }
  151.  
  152. void ResponseTest()
  153. {
  154.     long err, i;
  155.     KeMoParms parms;
  156.  
  157.     if (err = KeMoSelect(KeMoKey))        /* select the keyboard */
  158.         printf("\n*** Couldn't select keyboard only at this time (%ld).\n", err);
  159.     else {
  160.         printf("\nThis test calls KeMoWait repeatedly with a 2 second timeout.\n");
  161.         printf("Looking for 5 key down events: "); fflush(stdout);
  162.         for (i = 0; i < 5; i++) {
  163.             KeMoWait(KeMoDown, 2000L, &parms);
  164.             printf("%c-%s ", KeMoCode2Asc(parms.key), (parms.updown == KeMoDown ? "down" : 
  165.                 (parms.updown == KeMoUp ? "up" : 
  166.                 (parms.updown == KeMoTimedOut ? "timeout" : "???"))));
  167.             fflush(stdout);
  168.             }
  169.         printf("\n");
  170.  
  171.         printf("Looking for 5 key up events: "); fflush(stdout);
  172.         for (i = 0; i < 5; i++) {
  173.             KeMoWait(KeMoUp, 2000L, &parms);
  174.             printf("%c-%s ", KeMoCode2Asc(parms.key), (parms.updown == KeMoDown ? "down" : 
  175.                 (parms.updown == KeMoUp ? "up" : 
  176.                 (parms.updown == KeMoTimedOut ? "timeout" : "???"))));
  177.             fflush(stdout);
  178.             }
  179.         printf("\n");
  180.  
  181.         printf("Looking for 5 key up or down events: "); fflush(stdout);
  182.         for (i = 0; i < 5; i++) {
  183.             KeMoWait(KeMoUpDown, 2000L, &parms);
  184.             printf("%c-%s ", KeMoCode2Asc(parms.key), (parms.updown == KeMoDown ? "down" : 
  185.                 (parms.updown == KeMoUp ? "up" : 
  186.                 (parms.updown == KeMoTimedOut ? "timeout" : "???"))));
  187.             fflush(stdout);
  188.             }
  189.         printf("\n");
  190.         }
  191.         
  192.     if (err = KeMoSelect(KeMoMouse))
  193.         printf("\n*** Couldn't select mouse only at this time (%ld).\n", err);
  194.     else {
  195.         printf("Looking for 5 mouse down events: "); fflush(stdout);
  196.         for (i = 0; i < 5; i++) {
  197.             KeMoWait(KeMoDown, 2000L, &parms);
  198.             printf("button-%s ", (parms.updown == KeMoDown ? "down" : 
  199.                 (parms.updown == KeMoUp ? "up" : 
  200.                 (parms.updown == KeMoTimedOut ? "timeout" : "???"))));
  201.             fflush(stdout);
  202.             }
  203.         printf("\n");
  204.  
  205.         printf("Looking for 5 mouse up events: "); fflush(stdout);
  206.         for (i = 0; i < 5; i++) {
  207.             KeMoWait(KeMoUp, 2000L, &parms);
  208.             printf("button-%s ", (parms.updown == KeMoDown ? "down" : 
  209.                 (parms.updown == KeMoUp ? "up" : 
  210.                 (parms.updown == KeMoTimedOut ? "timeout" : "???"))));
  211.             fflush(stdout);
  212.             }
  213.         printf("\n");
  214.  
  215.         printf("Looking for 5 mouse up or down events: "); fflush(stdout);
  216.         for (i = 0; i < 5; i++) {
  217.             KeMoWait(KeMoUpDown, 2000L, &parms);
  218.             printf("button-%s ", (parms.updown == KeMoDown ? "down" : 
  219.                 (parms.updown == KeMoUp ? "up" : 
  220.                 (parms.updown == KeMoTimedOut ? "timeout" : "???"))));
  221.             fflush(stdout);
  222.             }
  223.         printf("\n");
  224.         }
  225.         
  226.     KeMoReset();
  227.     return;
  228. }
  229.  
  230. void AccuracyTest()
  231. {
  232.     float x;
  233.     short flag;
  234.     long err;
  235.     char ans[20];
  236.  
  237.     printf("\nTest [K]ey or [M]ouse? "); fflush(stdout);
  238.     fgets(ans, 10, stdin);
  239.     
  240.     switch (*ans) {
  241.         case 'k': flag = KeMoKey; break;
  242.         case 'm': flag = KeMoMouse; break;
  243.         default: printf("\nInvalid choice.\n"); return;
  244.         }
  245.     printf("\n%s it is!\n", flag & KeMoAllDevs ? "Both" : 
  246.                             ( flag & KeMoMouse ? "Mouse" : 
  247.                             ( flag & KeMoKey ? "Key" : "Up in the air")));
  248.     
  249.     
  250.     if (err = KeMoSelect(flag)) {
  251.         printf("\n*** Oops! That selection cannot be made at this time (%ld).\n", err);
  252.         return;
  253.         }
  254.     
  255.     printf("End the test by pressing the appropriate device.\n");
  256.     
  257.     x = KeMoAccuracy();    /* accuracy is returned in microseconds */
  258.     
  259.     KeMoReset();
  260.     
  261.     if (x < 0)
  262.         printf("\nThe desired accuracy test could not be performed: error %ld.\n", (long)x);
  263.     else
  264.         printf("\nThe timing accuracy is approximately +/- %0.1f msec.\n\n", 
  265.                     x/1000.0/2.0);
  266.         
  267.     return;
  268. }
  269.